home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume24 / gnucalc / part31 < prev    next >
Encoding:
Text File  |  1991-10-31  |  55.5 KB  |  1,440 lines

  1. Newsgroups: comp.sources.misc
  2. From: daveg@synaptics.com (David Gillespie)
  3. Subject:  v24i079:  gnucalc - GNU Emacs Calculator, v2.00, Part31/56
  4. Message-ID: <1991Oct31.214412.2242@sparky.imd.sterling.com>
  5. X-Md4-Signature: 94894bc0ce5693b5d214b3d54e153be0
  6. Date: Thu, 31 Oct 1991 21:44:12 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: daveg@synaptics.com (David Gillespie)
  10. Posting-number: Volume 24, Issue 79
  11. Archive-name: gnucalc/part31
  12. Environment: Emacs
  13. Supersedes: gmcalc: Volume 13, Issue 27-45
  14.  
  15. ---- Cut Here and unpack ----
  16. #!/bin/sh
  17. # do not concatenate these parts, unpack them in order with /bin/sh
  18. # file calc.texinfo continued
  19. #
  20. if test ! -r _shar_seq_.tmp; then
  21.     echo 'Please unpack part 1 first!'
  22.     exit 1
  23. fi
  24. (read Scheck
  25.  if test "$Scheck" != 31; then
  26.     echo Please unpack part "$Scheck" next!
  27.     exit 1
  28.  else
  29.     exit 0
  30.  fi
  31. ) < _shar_seq_.tmp || exit 1
  32. if test ! -f _shar_wnt_.tmp; then
  33.     echo 'x - still skipping calc.texinfo'
  34. else
  35. echo 'x - continuing file calc.texinfo'
  36. sed 's/^X//' << 'SHAR_EOF' >> 'calc.texinfo' &&
  37. X
  38. @node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc
  39. @subsection The Standard Calc Interface
  40. X
  41. @noindent
  42. Calc's standard interface acts like a traditional RPN calculator,
  43. operated by the normal Emacs keyboard.  When you type @kbd{M-# c}
  44. to start the Calculator, the Emacs screen splits into two windows
  45. with the file you were editing on top and Calc on the bottom.
  46. X
  47. @group
  48. @iftex
  49. @advance@hsize20pt
  50. @end iftex
  51. @smallexample
  52. X
  53. ...
  54. --**-Emacs: myfile             (Fundamental)----All----------------------
  55. --- Emacs Calculator Mode ---                   |Emacs Calc Mode v2.00...
  56. 2:  17.3                                        |    17.3
  57. 1:  -5                                          |    3
  58. X    .                                           |    2
  59. X                                                |    4
  60. X                                                |  * 8
  61. X                                                |  ->-5
  62. X                                                |
  63. --%%-Calc: 12 Deg       (Calculator)----All----- --%%-Emacs: *Calc Trail*
  64. @end smallexample
  65. @end group
  66. X
  67. In this figure, the mode-line for @file{myfile} has moved up and the
  68. ``Calculator'' window has appeared below it.  As you can see, Calc
  69. actually makes two windows side-by-side.  The lefthand one is
  70. called the @dfn{stack window} and the righthand one is called the
  71. @dfn{trail window.}  The stack holds the numbers involved in the
  72. calculation you are currently performing.  The trail holds a complete
  73. record of all calculations you have done.  In a desk calculator with
  74. a printer, the trail corresponds to the paper tape that records what
  75. you do.
  76. X
  77. In this case, the trail shows that four numbers (17.3, 3, 2, and 4)
  78. were first entered into the Calculator, then the 2 and 4 were
  79. multiplied to get 8, then the 3 and 8 were subtracted to get @i{-5}.
  80. (The @samp{>} symbol shows that this was the most recent calculation.)
  81. The net result is the two numbers 17.3 and @i{-5} sitting on the stack.
  82. X
  83. Most Calculator commands deal explicitly with the stack only, but
  84. there is a set of commands that allow you to search back through
  85. the trail and retrieve any previous result.
  86. X
  87. Calc commands use the digits, letters, and punctuation keys.
  88. Shifted (i.e., upper-case) letters are different from lowercase
  89. letters.  Some letters are @dfn{prefix} keys that begin two-letter
  90. commands.  For example, @kbd{e} means ``enter exponent'' and shifted
  91. @kbd{E} means @cite{e^x}.  With the @kbd{d} (``display modes'') prefix
  92. the letter ``e'' takes on very different meanings:  @kbd{d e} means
  93. ``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.''
  94. X
  95. There is nothing stopping you from switching out of the Calc
  96. window and back into your editing window, say by using the Emacs
  97. @w{@kbd{C-x o}} (@code{other-window}) command.  When the cursor is
  98. inside a regular window, Emacs acts just like normal.  When the
  99. cursor is in the Calc stack or trail windows, keys are interpreted
  100. as Calc commands.
  101. X
  102. When you quit by pressing @kbd{M-# c} a second time, the Calculator
  103. windows go away but the actual Stack and Trail are not gone, just
  104. hidden.  When you press @kbd{M-# c} once again you will get the
  105. same stack and trail contents you had when you last used the
  106. Calculator.
  107. X
  108. The Calculator does not remember its state between Emacs sessions.
  109. Thus if you quit Emacs and start it again, @kbd{M-# c} will give you
  110. a fresh stack and trail.  There is a command (@kbd{m m}) that lets
  111. you save your favorite mode settings between sessions, though.
  112. One of the things it saves is which user interface (standard or
  113. Keypad) you last used; otherwise, a freshly started Emacs will
  114. always treat @kbd{M-# M-#} the same as @kbd{M-# c}.
  115. X
  116. The @kbd{q} key is another equivalent way to turn the Calculator off.
  117. X
  118. If you type @kbd{M-# b} first and then @kbd{M-# c}, you get a
  119. full-screen version of Calc (@code{full-calc}) in which the stack and
  120. trail windows are still side-by-side but are now as tall as the whole
  121. Emacs screen.  When you press @kbd{q} or @kbd{M-# c} again to quit,
  122. the file you were editing before reappears.  The @kbd{M-# b} key
  123. switches back and forth between ``big'' full-screen mode and the
  124. normal partial-screen mode.
  125. X
  126. Finally, @kbd{M-# o} (@code{calc-other-window}) is like @kbd{M-# c}
  127. except that the Calc window is not selected.  The buffer you were
  128. editing before remains selected instead.  @kbd{M-# o} is a handy
  129. way to switch out of Calc momentarily to edit your file; type
  130. @kbd{M-# c} to switch back into Calc when you are done.
  131. X
  132. @node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc
  133. @subsection Quick Mode (Overview)
  134. X
  135. @noindent
  136. @dfn{Quick Mode} is a quick way to use Calc when you don't need the
  137. full complexity of the stack and trail.  To use it, type @kbd{M-# q}
  138. (@code{quick-calc}).
  139. X
  140. Quick Mode is very simple:  It prompts you to type any formula in
  141. standard algebraic notation (like @samp{4 - 2/3}) and then displays
  142. the result at the bottom of the Emacs screen (@i{3.33333333333}
  143. in this case).  You are then back in the same editing buffer you
  144. were in before, ready to continue editing or to type @kbd{M-# q}
  145. again to do another quick calculation.  The result of the calculation
  146. will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command
  147. at this point will yank the result into your editing buffer.
  148. X
  149. @c [fix-ref Quick Calculator mode]
  150. @xref{Quick Calculator}, for further information.
  151. X
  152. @node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc
  153. @subsection Keypad Mode (Overview)
  154. X
  155. @noindent
  156. @dfn{Keypad Mode} is a mouse-based interface to the Calculator.
  157. It is designed for use with the X window system.  If you don't
  158. have X, you will have to operate keypad mode with your arrow
  159. keys (which is probably more trouble than it's worth).
  160. X
  161. Type @kbd{M-# k} to turn Keypad Mode on or off.  Once again you
  162. get two new windows, this time on the righthand side of the screen
  163. instead of at the bottom.  The upper window is the familiar Calc
  164. Stack; the lower window is a picture of a typical calculator keypad.
  165. X
  166. @tex
  167. \dimen0=\pagetotal%
  168. \advance \dimen0 by 24\baselineskip%
  169. \ifdim \dimen0>\pagegoal \vfill\eject \fi%
  170. @end tex
  171. @smallexample
  172. X                                        |--- Emacs Calculator Mode ---
  173. X                                        |2:  17.3
  174. X                                        |1:  -5
  175. X                                        |    .
  176. X                                        |--%%-Calc: 12 Deg       (Calcul
  177. X                                        |----+-----Calc 2.00-----+----1
  178. X                                        |FLR |CEIL|RND |TRNC|CLN2|FLT |
  179. X                                        |----+----+----+----+----+----|
  180. X                                        | LN |EXP |    |ABS |IDIV|MOD |
  181. X                                        |----+----+----+----+----+----|
  182. X                                        |SIN |COS |TAN |SQRT|y^x |1/x |
  183. X                                        |----+----+----+----+----+----|
  184. X                                        |  ENTER  |+/- |EEX |UNDO| <- |
  185. X                                        |-----+---+-+--+--+-+---++----|
  186. X                                        | INV |  7  |  8  |  9  |  /  |
  187. X                                        |-----+-----+-----+-----+-----|
  188. X                                        | HYP |  4  |  5  |  6  |  *  |
  189. X                                        |-----+-----+-----+-----+-----|
  190. X                                        |EXEC |  1  |  2  |  3  |  -  |
  191. X                                        |-----+-----+-----+-----+-----|
  192. X                                        | OFF |  0  |  .  | PI  |  +  |
  193. X                                        |-----+-----+-----+-----+-----+
  194. @end smallexample
  195. @iftex
  196. @begingroup
  197. @ifdim@hsize=5in
  198. @vskip-3.7in
  199. @advance@hsize-2.2in
  200. @else
  201. @vskip-3.95in
  202. @advance@hsize-3.05in
  203. @advance@vsize.1in
  204. @fi
  205. @end iftex
  206. X
  207. Keypad Mode is much easier for beginners to learn, because there
  208. is no need to memorize lots of obscure key sequences.  But not all
  209. commands in regular Calc are available on the Keypad.  You can
  210. always switch the cursor into the Calc stack window to use
  211. standard Calc commands if you need.  Serious Calc users, though,
  212. often find they prefer the standard interface over Keypad Mode.
  213. X
  214. To operate the Calculator, just click on the ``buttons'' of the
  215. keypad using your left mouse button.  To enter the two numbers
  216. shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to
  217. add them together you would then click @kbd{+} (to get 12.3 on
  218. the stack).
  219. X
  220. If you click the right mouse button, the top three rows of the
  221. keypad change to show other sets of commands, such as advanced
  222. math functions, vector operations, and operations on binary
  223. numbers.
  224. X
  225. @iftex
  226. @endgroup
  227. @end iftex
  228. Because Keypad Mode doesn't use the regular keyboard, Calc leaves
  229. the cursor in your original editing buffer.  You can type in
  230. this buffer in the usual way while also clicking on the Calculator
  231. keypad.  One advantage of Keypad Mode is that you don't need an
  232. explicit command to switch between editing and calculating.
  233. X
  234. If you press @kbd{M-# b} first, you get a full-screen Keypad Mode
  235. (@code{full-calc-keypad}) with three windows:  The keypad in the lower
  236. left, the stack in the lower right, and the trail on top.
  237. X
  238. @c [fix-ref Keypad Mode]
  239. @xref{Keypad Mode}, for further information.
  240. X
  241. @node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc
  242. @subsection Standalone Operation
  243. X
  244. @noindent
  245. If you are not in Emacs at the moment but you wish to use Calc,
  246. you must start Emacs first.  If all you want is to run Calc, you
  247. can give the commands:
  248. X
  249. @example
  250. emacs -f full-calc
  251. @end example
  252. X
  253. @noindent
  254. or
  255. X
  256. @example
  257. emacs -f full-calc-keypad
  258. @end example
  259. X
  260. @noindent
  261. which run a full-screen Calculator (as if by @kbd{M-# b M-# c}) or
  262. a full-screen X-based Calculator (as if by @kbd{M-# b M-# k}).
  263. In standalone operation, quitting the Calculator (by pressing
  264. @kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs
  265. itself.
  266. X
  267. @node Embedded Mode Overview, Other M-# Commands, Standalone Operation, Using Calc
  268. @subsection Embedded Mode (Overview)
  269. X
  270. @noindent
  271. @dfn{Embedded Mode} is a way to use Calc directly from inside an
  272. editing buffer.  Suppose you have a formula written as part of a
  273. document like this:
  274. X
  275. @group
  276. @smallexample
  277. The derivative of
  278. X
  279. X                                   ln(ln(x))
  280. X
  281. is
  282. @end smallexample
  283. @end group
  284. X
  285. @noindent
  286. and you wish to have Calc compute and format the derivative for
  287. you and store this derivative in the buffer automatically.  To
  288. do this with Embedded Mode, first copy the formula down to where
  289. you want the result to be:
  290. X
  291. @group
  292. @smallexample
  293. The derivative of
  294. X
  295. X                                   ln(ln(x))
  296. X
  297. is
  298. X
  299. X                                   ln(ln(x))
  300. @end smallexample
  301. @end group
  302. X
  303. Now, move the cursor onto this new formula and press @kbd{M-# e}.
  304. Calc will read the formula (using the surrounding blank lines to
  305. tell how much text to read), then push this formula (invisibly)
  306. onto the Calc stack.  The cursor will stay on the formula in the
  307. editing buffer, but the buffer's mode line will change to look
  308. like the Calc mode line (with mode indicators like @samp{12 Deg}
  309. and so on).  Even though you are still in your editing buffer,
  310. the keyboard now acts like the Calc keyboard, and any new result
  311. you get is copied from the stack back into the buffer.  To take
  312. the derivative, you would type @kbd{a d x @key{RET}}.
  313. X
  314. @group
  315. @smallexample
  316. The derivative of
  317. X
  318. X                                   ln(ln(x))
  319. X
  320. is
  321. X
  322. 1 / ln(x) x
  323. @end smallexample
  324. @end group
  325. X
  326. To make this look nicer, you might want to press @kbd{d =} to center
  327. the formula, and even @kbd{d B} to use ``big'' display mode.
  328. X
  329. @group
  330. @smallexample
  331. The derivative of
  332. X
  333. X                                   ln(ln(x))
  334. X
  335. is
  336. % [calc-mode: justify: center]
  337. % [calc-mode: language: big]
  338. X
  339. X                                       1
  340. X                                    -------
  341. X                                    ln(x) x
  342. @end smallexample
  343. @end group
  344. X
  345. Calc has added annotations to the file to help it remember the modes
  346. that were used for this formula.  They are formatted like comments
  347. in the @TeX{} typesetting language, just in case you are using @TeX{}.
  348. (In this example @TeX{} is not being used, so you might want to move
  349. these comments up to the top of the file or otherwise put them out
  350. of the way.)
  351. X
  352. As an extra flourish, we can add an equation number using a
  353. righthand label:  Type @kbd{d @} (1) RET}.
  354. X
  355. @group
  356. @smallexample
  357. % [calc-mode: justify: center]
  358. % [calc-mode: language: big]
  359. % [calc-mode: right-label: " (1)"]
  360. X
  361. X                                       1
  362. X                                    -------                      (1)
  363. X                                    ln(x) x
  364. @end smallexample
  365. @end group
  366. X
  367. To leave Embedded Mode, type @kbd{M-# e} again.  The mode line
  368. and keyboard will revert to the way they were before.  (If you have
  369. actually been trying this as you read along, you'll want to press
  370. @kbd{M-# 0} [with the digit zero] now to reset the modes you changed.)
  371. X
  372. The related command @kbd{M-# w} operates on a single word, which
  373. generally means a single number, inside text.  It uses any
  374. non-numeric characters rather than blank lines to delimit the
  375. formula it reads.  Here's an example of its use:
  376. X
  377. @smallexample
  378. A slope of one-third corresponds to an angle of 1 degrees.
  379. @end smallexample
  380. X
  381. Place the cursor on the @samp{1}, then type @kbd{M-# w} to enable
  382. Embedded Mode on that number.  Now type @kbd{3 /} (to get one-third),
  383. and @kbd{I T} (the Inverse Tangent converts a slope into an angle),
  384. then @kbd{M-# w} again to exit Embedded mode.
  385. X
  386. @smallexample
  387. A slope of one-third corresponds to an angle of 18.4349488229 degrees.
  388. @end smallexample
  389. X
  390. @c [fix-ref Embedded Mode]
  391. @xref{Embedded Mode}, for full details.
  392. X
  393. @node Other M-# Commands, , Embedded Mode Overview, Using Calc
  394. @subsection Other @kbd{M-#} Commands
  395. X
  396. @noindent
  397. Two more Calc-related commands are @kbd{M-# g} and @kbd{M-# r},
  398. which ``grab'' data from a selected region of a buffer into the
  399. Calculator.  The region is defined in the usual Emacs way, by
  400. a ``mark'' placed at one end of the region, and the Emacs
  401. cursor or ``point'' placed at the other.
  402. X
  403. The @kbd{M-# g} command reads the region in the usual left-to-right,
  404. top-to-bottom order.  The result is packaged into a Calc vector
  405. of numbers and placed on the stack.  Calc (in its standard
  406. user interface) is then started.  Type @kbd{v u} if you want
  407. to unpack this vector into separate numbers on the stack.  Also,
  408. @kbd{C-u M-# g} interprets the region as a single number or
  409. formula.
  410. X
  411. The @kbd{M-# r} command reads a rectangle, with the point and
  412. mark defining opposite corners of the rectangle.  The result
  413. is a matrix of numbers on the Calculator stack.
  414. X
  415. Complementary to these is @kbd{M-# y}, which ``yanks'' the
  416. value at the top of the Calc stack back into an editing buffer.
  417. If you type @w{@kbd{M-# y}} while in such a buffer, the value is
  418. yanked at the current position.  If you type @kbd{M-# y} while
  419. in the Calc buffer, Calc makes an educated guess as to which
  420. editing buffer you want to use.  The Calc window does not have
  421. to be visible in order to use this command, as long as there
  422. is something on the Calc stack.
  423. X
  424. Here, for reference, is the complete list of @kbd{M-#} commands.
  425. The shift, control, and meta keys are ignored for the keystroke
  426. following @kbd{M-#}.
  427. X
  428. @noindent
  429. Commands for turning Calc on and off:
  430. X
  431. @table @kbd
  432. @item #
  433. Turn Calc on or off, employing the same user interface as last time.
  434. X
  435. @item C
  436. Turn Calc on or off using its standard bottom-of-the-screen
  437. interface.  If Calc is already turned on but the cursor is not
  438. in the Calc window, move the cursor into the window.
  439. X
  440. @item O
  441. Same as @kbd{C}, but don't select the new Calc window.  If
  442. Calc is already turned on and the cursor is in the Calc window,
  443. move it out of that window.
  444. X
  445. @item B
  446. Control whether @kbd{M-# c} and @kbd{M-# k} use the full screen.
  447. X
  448. @item Q
  449. Use Quick Mode for a single short calculation.
  450. X
  451. @item K
  452. Turn Calc Keypad mode on or off.
  453. X
  454. @item E
  455. Turn Calc Embedded mode on or off at the current formula.
  456. X
  457. @item J
  458. Turn Calc Embedded mode on or off, select the interesting part.
  459. X
  460. @item W
  461. Turn Calc Embedded mode on or off at the current word (number).
  462. X
  463. @item Z
  464. Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command.
  465. X
  466. @item X
  467. Quit Calc; turn off standard, Keypad, or Embedded mode if on.
  468. (This is like @kbd{q} or @key{OFF} inside of Calc.)
  469. @end table
  470. @iftex
  471. @sp 2
  472. @end iftex
  473. X
  474. @group
  475. @noindent
  476. Commands for moving data into and out of the Calculator:
  477. X
  478. @table @kbd
  479. @item G
  480. Grab the region into the Calculator as a vector.
  481. X
  482. @item R
  483. Grab the rectangular region into the Calculator as a matrix.
  484. X
  485. @item :
  486. Grab the rectangular region and compute the sums of its columns.
  487. X
  488. @item _
  489. Grab the rectangular region and compute the sums of its rows.
  490. X
  491. @item Y
  492. Yank a value from the Calculator into the current editing buffer.
  493. @end table
  494. @iftex
  495. @sp 2
  496. @end iftex
  497. @end group
  498. X
  499. @group
  500. @noindent
  501. Commands for use with Embedded Mode:
  502. X
  503. @table @kbd
  504. @item A
  505. ``Activate'' the current buffer.  Locate all formulas that
  506. contain @samp{:=} or @samp{=>} symbols and record their locations
  507. so that they can be updated automatically as variables are changed.
  508. X
  509. @item D
  510. Duplicate the current formula immediately below and select
  511. the duplicate.
  512. X
  513. @item F
  514. Insert a new formula at the current point.
  515. X
  516. @item N
  517. Move the cursor to the next active formula in the buffer.
  518. X
  519. @item P
  520. Move the cursor to the previous active formula in the buffer.
  521. X
  522. @item U
  523. Update (i.e., as if by the @kbd{=} key) the formula at the current point.
  524. X
  525. @item `
  526. Edit (as if by @code{calc-edit}) the formula at the current point.
  527. @end table
  528. @iftex
  529. @sp 2
  530. @end iftex
  531. @end group
  532. X
  533. @group
  534. @noindent
  535. Miscellaneous commands:
  536. X
  537. @table @kbd
  538. @item I
  539. Run the Emacs Info system to read the Calc manual.
  540. (This is the same as @kbd{h i} inside of Calc.)
  541. X
  542. @item T
  543. Run the Emacs Info system to read the Calc Tutorial.  This uses
  544. @kbd{M-# i} and @kbd{M-# c} to start the Info system and make
  545. a Calc window, then switches the Info system to the start
  546. of the tutorial.
  547. X
  548. @item S
  549. Run the Emacs Info system to read the Calc Summary.
  550. X
  551. @item L
  552. Load Calc entirely into memory.  (Normally the various parts
  553. are loaded only as they are needed.)
  554. X
  555. @item M
  556. Read a region of written keystroke names (like @samp{C-n a b c RET})
  557. and record them as the current keyboard macro.
  558. X
  559. @item 0
  560. (This is the ``zero'' digit key.)  Reset the Calculator to
  561. its default state:  Empty stack, and default mode settings.
  562. With any prefix argument, reset everything but the stack.
  563. @end table
  564. @end group
  565. X
  566. @node Demonstration of Calc, New for Calc 2.00, Using Calc, Getting Started
  567. @section A Demonstration of Calc
  568. X
  569. @noindent
  570. This section will show some typical small problems being solved with
  571. Calc.  The focus is more on demonstration than explanation, but
  572. everything you see here will be covered more thoroughly in the
  573. Tutorial.
  574. X
  575. To begin, type @kbd{M-# c} to start the Calculator.  Be sure to type
  576. all the sample input exactly, especially the difference between
  577. lower-case and upper-case letters.  Remember, @kbd{RET}, @kbd{TAB},
  578. @kbd{DEL}, and @kbd{SPC} are the Return, Tab, Delete, and Space keys.
  579. X
  580. @strong{RPN calculation.}  In RPN, you type the input number(s) first,
  581. then the command to operate on the numbers.
  582. X
  583. @noindent
  584. Type @kbd{2 RET 3 + Q} to compute @c{$\sqrt{2+3}$}
  585. @asis{the square root of 2+3}.
  586. X
  587. @noindent
  588. Type @kbd{P 2 ^} to compute @c{$\pi^2$}
  589. @asis{the value of `pi' squared}.
  590. X
  591. @noindent
  592. Type @kbd{TAB} to exchange the order of these two results.
  593. X
  594. @noindent
  595. Type @kbd{- I H S} to subtract these results and compute the Inverse
  596. Hyperbolic sine of the difference, 2.72996136574.
  597. X
  598. @noindent
  599. Type @kbd{DEL} to erase this result.
  600. X
  601. @strong{Algebraic calculation.}  To enter a calculation using
  602. conventional ``algebraic'' notation, use the apostrophe key.
  603. X
  604. @noindent
  605. Type @kbd{' sqrt(2+3) RET} to compute @c{$\sqrt{2+3}$}
  606. @asis{the square root of 2+3}.
  607. X
  608. @noindent
  609. Type @kbd{' pi^2 RET} to enter @c{$\pi^2$}
  610. @asis{`pi' squared}.  To evaluate this symbolic
  611. formula as a number, type @kbd{=}.
  612. X
  613. @noindent
  614. Type @kbd{' arcsinh($ - $$) RET} to subtract the second-most-recent
  615. result from the most-recent and compute the Inverse Hyperbolic sine.
  616. X
  617. @strong{Keypad mode.}  If you are using the X window system, press
  618. @w{@kbd{M-# k}} to get Keypad mode.
  619. X
  620. @noindent
  621. Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT}
  622. ``buttons'' using your left mouse button.
  623. X
  624. @noindent
  625. Click on @key{PI}, @key{2}, and @key{y^x}.
  626. X
  627. @noindent
  628. Click on @key{INV}, then @key{ENTER} to swap the two results.
  629. X
  630. @noindent
  631. Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}.
  632. X
  633. @noindent
  634. Click on @key{<-} to erase the result, then click @key{OFF} to turn
  635. the Keypad Calculator off.
  636. X
  637. @strong{Grabbing data.}  Type @kbd{M-# x} if necessary to exit Calc.
  638. Now select the following numbers as an Emacs region:  ``Mark'' the
  639. front of the list by typing control-@kbd{SPC} or control-@kbd{@@} there,
  640. then move to the other end of the list.  Now type @kbd{M-# g} to ``grab''
  641. these numbers into Calc.
  642. X
  643. @group
  644. @example
  645. 1.23  1.97
  646. 1.6   2
  647. 1.19  1.08
  648. @end example
  649. @end group
  650. X
  651. @noindent
  652. The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.''
  653. Type @w{@kbd{V R +}} to compute the sum of these numbers.
  654. X
  655. @noindent
  656. Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute
  657. the product of the numbers.
  658. X
  659. @noindent
  660. You can also grab data as a rectangular matrix.  Place the cursor on
  661. the upper-leftmost @samp{1} and set the mark, then move to just after
  662. the lower-right @samp{8} and press @kbd{M-# r}.
  663. X
  664. @noindent
  665. Type @kbd{v t} to transpose this @c{$3\times2$}
  666. @asis{3x2} matrix into a @c{$2\times3$}
  667. @asis{2x3} matrix.  Type
  668. @w{@kbd{v u}} to unpack the rows into two separate vectors.  Now type
  669. @w{@kbd{V R + TAB V R +}} to compute the sums of the two original columns.
  670. (There is also a special grab-and-sum-columns command, @kbd{M-# :}.)
  671. X
  672. @strong{Units conversion.}  Units are entered algebraically.
  673. Type @w{@kbd{' 43 mi/hr RET}} to enter the quantity 43 miles-per-hour.
  674. Type @w{@kbd{u c km/hr RET}}.  Type @w{@kbd{u c m/s RET}}.
  675. X
  676. @strong{Date arithmetic.}  Type @kbd{t N} to get the current date and
  677. time.  Type @kbd{90 +} to find the date 90 days from now.  Type
  678. @kbd{' <25 dec 87> RET} to enter a date, then @kbd{- 7 /} to see how
  679. many weeks have passed since then.
  680. X
  681. @strong{Algebra.}  Algebraic entries can include formulas
  682. or equations involving variables.  Type @kbd{' [x + y = a, x y = 1] RET}
  683. to enter a pair of equations involving three variables.  Type
  684. @kbd{a S x,y RET} to solve these equations for the variables @cite{x}
  685. and @cite{y}.
  686. X
  687. @noindent
  688. Type @kbd{d B} to view the solutions in more readable notation.
  689. Type @w{@kbd{d C}} to view them in C language notation, and @kbd{d T}
  690. to view them in the notation for the @TeX{} typesetting system.
  691. Type @kbd{d N} to return to normal notation.
  692. X
  693. @noindent
  694. Type @kbd{7.5 s l a RET} to let @cite{a = 7.5} in these formulas.
  695. X
  696. @strong{Help functions.}  You can read about any command in the on-line
  697. manual.  If you are reading this demonstration on-line, remember to type
  698. the letter @kbd{l}, then @kbd{M-# c}, to return here after each of these
  699. commands: @w{@kbd{h k t N}} to read about the @w{@kbd{t N}} command,
  700. @kbd{h f sqrt RET} to read about the @code{sqrt} function, and @kbd{h s}
  701. to read the Calc summary.
  702. X
  703. Press @kbd{DEL} repeatedly to remove any leftover results from the stack.
  704. X
  705. @node New for Calc 2.00, History and Acknowledgements, Demonstration of Calc, Getting Started
  706. @section New for Calc 2.00
  707. X
  708. If you are upgrading from Calc 1.07, you will find many new features and
  709. changes in this version of Calc.  This section is a summary of the major
  710. areas of improvement, but it doesn't list every minor change.  The
  711. @file{README.prev} file that comes with the Calc FTP distribution contains
  712. a more complete list of all changes that have appeared in every version
  713. of Calc.
  714. X
  715. @strong{Installation.}  The installation procedure has been completely
  716. redone.  Calc is now compatible with the Unix @code{make} utility:  A
  717. single Unix command compiles and installs Calc and formats the on-line
  718. Info documentation.  Calc is now much more forgiving about being moved
  719. to a new directory after being compiled.
  720. X
  721. @strong{Start-up.}  The @kbd{M-#} key is now a prefix; followed by
  722. various letters, it allows quick access to several different Calc
  723. user interfaces and related functions, such as @code{quick-calc}
  724. and @code{calc-grab-region}.  Quitting Calc now tries to preserve
  725. the old configuration of windows.
  726. X
  727. @strong{Display.}  Language modes for @dfn{eqn} and Maple were added.
  728. Big mode now has many more special formats, such as square roots, sums,
  729. and fractions.  Radix modes now work with floating-point numbers.
  730. Long lines in the display are broken more intelligently.  ``Composition
  731. functions'' allow you to define your own special display formats.  It
  732. is now possible to change display modes without redrawing the entire
  733. stack.
  734. X
  735. @strong{Keyboard.}  The @kbd{M-DEL} key deletes the second-from-top
  736. stack element.  The @kbd{@{} and @kbd{@}} keys scroll the stack display
  737. vertically.  The @kbd{m t} command enables ``total'' algebraic mode,
  738. where algebraic entry is used all the time.  The @kbd{s} (store)
  739. key has become a prefix key, with options for storing, recalling,
  740. exchanging, modifying, and editing variables.  With an equation on the
  741. stack, ``store'' and ``let'' default to taking the variable name and
  742. value from the two sides of the equation.  Matrix mapping modes for
  743. @kbd{V M} and @kbd{V R} have been replaced with a new system that is
  744. easier to remember and less error-prone, and a new notation for nameless
  745. functions has been introduced in place of @code{lambda} expressions.
  746. X
  747. @strong{Functions.}  Several financial functions were added, as were a
  748. number of statistical functions.  Least-squares curve fitting, including
  749. multilinear and many nonlinear models, is supported.  Functions left
  750. unevaluated now actively report the problem rather than waiting for you
  751. to press @kbd{w}.  Arithmetic now does overflow and underflow checking
  752. on all floating-point results.  The @code{random} function can now be
  753. seeded by a user-specified value.  New @code{gamma} and @code{phi}
  754. special constants complement @code{pi}, @code{e}, and @code{i}.
  755. X
  756. @strong{Data types.}  Date forms, with several date arithmetic functions,
  757. were added.  Fractions can be displayed with a fixed denominator.  Calc
  758. now understands the concept of ``infinity,'' including infinite intervals.
  759. Error forms can now include complex numbers.  Units have several new
  760. features, including composite units (@code{mi+ft+in}), automatic prefix
  761. adjustment as an option (@samp{3000 m} converts to @samp{3 km}), and a
  762. new-and-improved table of predefined units.
  763. X
  764. @strong{Algebra.}  The equation solver can do many more kinds of equations,
  765. and can solve systems of equations.  All roots of a polynomial can now be
  766. found numerically if symbolic methods fail.  Many new polynomial operations
  767. exist, such as division, GCD, factorization, and partial fractions.  The
  768. integrator now handles many common types of integrals, and numerical
  769. integration is also supported.  Sums and products, including closed-form
  770. solutions and infinite sums in certain cases, are possible.  Default
  771. simplifications have been improved in various ways, and are now fully
  772. documented.  Simplification is now more careful about branch cuts.
  773. Declarations for variables are supported; variables can be declared real,
  774. positive, matrix or scalar, etc., allowing better simplification of
  775. formulas involving them.
  776. X
  777. @strong{Graphics.}  Together with GNUPLOT 3.0, several new options exist
  778. including 3D graphs of functions or data.  Plotting to an Emacs window
  779. using ``ASCII graphics'' is now supported, and there is a better interface
  780. for Tektronix graphics terminals.
  781. X
  782. @strong{Rewrite rules.}  The variable @code{EvalRules} contains rules to
  783. be applied every time a formula is evaluated; this allows you to define
  784. your own functions or default simplifications using rewrites.  The new
  785. notation @samp{@var{old} := @var{new} :: @var{condition}} is supported
  786. for rewrites.  Operators @code{&&&}, @code{|||}, and @code{!!!} allow
  787. and/or/not combinations of rewrite patterns.  Rewriting may be broken
  788. into multiple independent phases.  The Calc Tutorial now has a section
  789. on rewrite rules.
  790. X
  791. @strong{Embedded mode.}  It is now possible to run Calc on numbers and
  792. formulas directly inside your editing buffer.  While a value is ``live,''
  793. regular Calc keystrokes operate on the value as if it were on the Calc
  794. stack.
  795. X
  796. @strong{Documentation.}  The @kbd{h} key is now a prefix, with options
  797. for reading the manual or tutorial, or for looking up any key, command,
  798. function, or variable in the manual automatically.  (Most regular Emacs
  799. @kbd{C-h f} documentation was removed to save space.)  A complete
  800. ``summary'' appendix was added to the manual.  Parts of the manual
  801. were rearranged or rewritten, particularly the ``Getting Started''
  802. chapter.  Minor improvements were made throughout the manual.
  803. X
  804. @node History and Acknowledgements, , New for Calc 2.00, Getting Started
  805. @section History and Acknowledgements
  806. X
  807. @noindent
  808. Calc was originally started as a two-week project to occupy a lull
  809. in the author's schedule.  Basically, a friend asked if I remembered
  810. the value of @c{$2^{32}$}
  811. @cite{2^32}.  I didn't offhand, but I said, ``that's
  812. easy, just call up an @code{xcalc}.''  @code{Xcalc} duly reported
  813. that the answer to our question was @samp{4.294967e+09}---with no way to
  814. see the full ten digits even though we knew they were there in the
  815. program's memory!  I was so annoyed, I vowed to write a calculator
  816. of my own, once and for all.
  817. X
  818. I chose Emacs Lisp, a) because I had always been curious about it
  819. and b) because, being only a text editor extension language after
  820. all, Emacs Lisp would surely reach its limits long before the project
  821. got too far out of hand.
  822. X
  823. To make a long story short, Emacs Lisp turned out to be a distressingly
  824. solid implementation of Lisp, and the humble task of calculating
  825. turned out to be more open-ended than one might have expected.
  826. X
  827. Emacs Lisp doesn't have built-in floating point math, so it had to be
  828. simulated in software.  In fact, Emacs integers will only comfortably
  829. fit six decimal digits or so---not enough for a decent calculator.  So
  830. I had to write my own high-precision integer code as well, and once I had
  831. this I figured that arbitrary-size integers were just as easy as large
  832. integers.  Arbitrary floating-point precision was the logical next step.
  833. Also, since the large integer arithmetic was there anyway it seemed only
  834. fair to give the user direct access to it, which in turn made it practical
  835. to support fractions as well as floats.  All these features inspired me
  836. to look around for other data types that might be worth having.
  837. X
  838. Around this time, my friend Rick Koshi showed me his nifty new HP-28
  839. calculator.  It allowed the user to manipulate formulas as well as
  840. numerical quantities, and it could also operate on matrices.  I decided
  841. that these would be good for Calc to have, too.  And once things had
  842. gone this far, I figured I might as well take a look at serious algebra
  843. systems like Mathematica, Macsyma, and Maple for further ideas.  Since
  844. these systems did far more than I could ever hope to implement, I decided
  845. to focus on rewrite rules and other programming features so that users
  846. could implement what they needed for themselves.
  847. X
  848. Rick complained that matrices were hard to read, so I put in code to
  849. format them in a 2D style.  Once these routines were in place, Big mode
  850. was obligatory.  Gee, what other language modes would be useful?
  851. X
  852. Scott Hemphill and Allen Knutson, two friends with a strong mathematical
  853. bent, contributed ideas and algorithms for a number of Calc features
  854. including modulo forms, primality testing, and float-to-fraction conversion.
  855. X
  856. Units were added at the eager insistence of Mass Sivilotti.  Later,
  857. Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
  858. expert assistance with the units table.  As far as I can remember, the
  859. idea of using algebraic formulas and variables to represent units dates
  860. back to an ancient article in Byte magazine about muMath, an early
  861. algebra system for microcomputers.
  862. X
  863. Many people have contributed to Calc by reporting bugs and suggesting
  864. features, large and small.  A few deserve special mention:  Tim Peters,
  865. who helped develop the ideas that led to the selection commands, rewrite
  866. rules, and many other algebra features; @c{Fran\c cois}
  867. @asis{Francois} Pinard, who contributed
  868. an early prototype of the Calc Summary appendix as well as providing
  869. valuable suggestions in many other areas of Calc; Carl Witty, whose eagle
  870. eyes discovered many typographical and factual errors in the Calc manual;
  871. Tim Kay, who drove the development of Embedded mode; Ove Ewerlid, who
  872. made many suggestions relating the the algebra commands and contributed
  873. some code for polynomial operations; Randal Schwartz, who suggested the
  874. @code{calc-eval} function; Bob Chassell, who suggested the Calc Tutorial
  875. and exercises; and Juha Sarlin, who first worked out how to split Calc
  876. into quickly-loading parts.
  877. X
  878. @c Should these be expanded into more complete references?
  879. Among the books used in the development of Calc were Knuth's @emph{Art
  880. of Computer Programming} (especially volume II, @emph{Seminumerical
  881. Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky,
  882. and Vetterling; Bevington's @emph{Data Reduction and Error Analysis for
  883. the Physical Sciences}; @emph{Concrete Mathematics} by Graham, Knuth,
  884. and Patashnik; Steele's @emph{Common Lisp, the Language}; the @emph{CRC
  885. Standard Math Tables} (William H. Beyer, ed.); and Abramowitz and
  886. Stegun's venerable @emph{Handbook of Mathematical Functions}.  I
  887. consulted the user's manuals for the HP-28 and HP-48 calculators, as
  888. well as for the programs Mathematica, SMP, Macsyma, Maple, MathCAD,
  889. Gnuplot, and others.  Also, of course, Calc could not have been written
  890. without the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil
  891. Lewis and Dan LaLiberte.
  892. X
  893. Final thanks go to Richard Stallman, without whose fine implementations
  894. of the Emacs editor, language, and environment, Calc would have been
  895. finished in two weeks.
  896. X
  897. @c [tutorial]
  898. X
  899. @ifinfo
  900. @c This node is accessed by the `M-# t' command.
  901. @node Interactive Tutorial, , , Top
  902. @chapter Tutorial
  903. X
  904. @noindent
  905. Some brief instructions on using the Emacs Info system for this tutorial:
  906. X
  907. Press the space bar and Delete keys to go forward and backward in a
  908. section by screenfuls (or use the regular Emacs scrolling commands
  909. for this).
  910. X
  911. Press @kbd{n} or @kbd{p} to go to the Next or Previous section.
  912. If the section has a @dfn{menu}, press a digit key like @kbd{1}
  913. or @kbd{2} to go to a sub-section from the menu.  Press @kbd{u} to
  914. go back up from a sub-section to the menu it is part of.
  915. X
  916. Exercises in the tutorial all have cross-references to the
  917. appropriate page of the ``answers'' section.  Press @kbd{f}, then
  918. the exercise number, to see the answer to an exercise.  After
  919. you have followed a cross-reference, you can press the letter
  920. @kbd{l} to return to where you were before.
  921. X
  922. You can press @kbd{?} at any time for a brief summary of Info commands.
  923. X
  924. Press @kbd{1} now to enter the first section of the Tutorial.
  925. X
  926. @menu
  927. * Tutorial::
  928. @end menu
  929. @end ifinfo
  930. X
  931. @node Tutorial, Introduction, Getting Started, Top
  932. @chapter Tutorial
  933. X
  934. @noindent
  935. This chapter explains how to use Calc and its many features, in
  936. a step-by-step, tutorial way.  You are encouraged to run Calc and
  937. work along with the examples as you read (@pxref{Starting Calc}).
  938. If you are already familiar with advanced calculators, you may wish
  939. @c [not-split]
  940. to skip on to the rest of this manual.
  941. @c [when-split]
  942. @c to skip on to volume II of this manual, the @dfn{Calc Reference}.
  943. X
  944. @c [fix-ref Embedded Mode]
  945. This tutorial describes the standard user interface of Calc only.
  946. The ``Quick Mode'' and ``Keypad Mode'' interfaces are fairly
  947. self-explanatory.  @xref{Embedded Mode}, for a description of
  948. the ``Embedded Mode'' interface.
  949. X
  950. @ifinfo
  951. The easiest way to read this tutorial on-line is to have two windows on
  952. your Emacs screen, one with Calc and one with the Info system.  (If you
  953. have a printed copy of the manual you can use that instead.)  Press
  954. @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
  955. press @kbd{M-# i} to start the Info system or to switch into its window.
  956. Or, you may prefer to use the tutorial in printed form.
  957. @end ifinfo
  958. @iftex
  959. The easiest way to read this tutorial on-line is to have two windows on
  960. your Emacs screen, one with Calc and one with the Info system.  (If you
  961. have a printed copy of the manual you can use that instead.)  Press
  962. @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
  963. press @kbd{M-# i} to start the Info system or to switch into its window.
  964. @end iftex
  965. X
  966. This tutorial is designed to be done in sequence.  But the rest of this
  967. manual does not assume you have gone through the tutorial.  The tutorial
  968. does not cover everything in the Calculator, but it touches on most
  969. general areas.
  970. X
  971. @ifinfo
  972. You may wish to print out a copy of the Calc Summary and keep notes on
  973. it as you learn Calc.  @xref{Installation}, to see how to make a printed
  974. summary.  @xref{Summary}.
  975. @end ifinfo
  976. @iftex
  977. The Calc Summary at the end of the reference manual includes some blank
  978. space for your own use.  You may wish to keep notes there as you learn
  979. Calc.
  980. @end iftex
  981. X
  982. @menu
  983. * Basic Tutorial::
  984. * Arithmetic Tutorial::
  985. * Vector/Matrix Tutorial::
  986. * Types Tutorial::
  987. * Algebra Tutorial::
  988. * Programming Tutorial::
  989. X
  990. * Answers to Exercises::
  991. @end menu
  992. X
  993. @node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial
  994. @section Basic Tutorial
  995. X
  996. @noindent
  997. In this section, we learn how RPN and algebraic-style calculations
  998. work, how to undo and redo an operation done by mistake, and how
  999. to control various modes of the Calculator.
  1000. X
  1001. @menu
  1002. * RPN Tutorial::            Basic operations with the stack.
  1003. * Algebraic Tutorial::      Algebraic entry; variables.
  1004. * Undo Tutorial::           If you make a mistake: Undo and the trail.
  1005. * Modes Tutorial::          Common mode-setting commands.
  1006. @end menu
  1007. X
  1008. @node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial
  1009. @subsection RPN Calculations and the Stack
  1010. X
  1011. @cindex RPN notation
  1012. @ifinfo
  1013. @noindent
  1014. Calc normally uses RPN notation.  You may be familiar with the RPN
  1015. system from Hewlett-Packard calculators, FORTH, or PostScript.
  1016. (Reverse Polish Notation, RPN, is named after the Polish mathematician
  1017. Jan Lukasiewicz.)
  1018. @end ifinfo
  1019. @tex
  1020. \noindent
  1021. Calc normally uses RPN notation.  You may be familiar with the RPN
  1022. system from Hewlett-Packard calculators, FORTH, or PostScript.
  1023. (Reverse Polish Notation, RPN, is named after the Polish mathematician
  1024. Jan \L ukasiewicz.)
  1025. @end tex
  1026. X
  1027. The central component of an RPN calculator is the @dfn{stack}.  A
  1028. calculator stack is like a stack of dishes.  New dishes (numbers) are
  1029. added at the top of the stack, and numbers are normally only removed
  1030. from the top of the stack.
  1031. X
  1032. @cindex Operators
  1033. @cindex Operands
  1034. In an operation like @cite{2+3}, the 2 and 3 are called the @dfn{operands}
  1035. and the @cite{+} is the @dfn{operator}.  In an RPN calculator you always
  1036. enter the operands first, then the operator.  Each time you type a
  1037. number, Calc adds or @dfn{pushes} it onto the top of the Stack.
  1038. When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate
  1039. number of operands from the stack and pushes back the result.
  1040. X
  1041. Thus we could add the numbers 2 and 3 in an RPN calculator by typing:
  1042. @kbd{2 @key{RET} 3 @key{RET} +}.  (The @key{RET} key, Return, corresponds to
  1043. the @key{ENTER} key on traditional RPN calculators.)  Try this now if
  1044. you wish; type @kbd{M-# c} to switch into the Calc window (you can type
  1045. @kbd{M-# c} again or @kbd{M-# o} to switch back to the Tutorial window).
  1046. The first four keystrokes ``push'' the numbers 2 and 3 onto the stack.
  1047. The @kbd{+} key ``pops'' the top two numbers from the stack, adds them,
  1048. and pushes the result (5) back onto the stack.  Here's how the stack
  1049. will look at various points throughout the calculation:@refill
  1050. X
  1051. @group
  1052. @smallexample
  1053. X    .          1:  2          2:  2          1:  5              .
  1054. X                   .          1:  3              .
  1055. X                                  .
  1056. X
  1057. X  M-# c          2 RET          3 RET            +             DEL
  1058. @end smallexample
  1059. @end group
  1060. X
  1061. The @samp{.} symbol is a marker that represents the top of the stack.
  1062. Note that the ``top'' of the stack is really shown at the bottom of
  1063. the Stack window.  This may seem backwards, but it turns out to be
  1064. less distracting in regular use.
  1065. X
  1066. @cindex Stack levels
  1067. @cindex Levels of stack
  1068. The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level
  1069. numbers}.  Old RPN calculators always had four stack levels called
  1070. @cite{x}, @cite{y}, @cite{z}, and @cite{t}.  Calc's stack can grow
  1071. as large as you like, so it uses numbers instead of letters.  Some
  1072. stack-manipulation commands accept a numeric argument that says
  1073. which stack level to work on.  Normal commands like @kbd{+} always
  1074. work on the top few levels of the stack.@refill
  1075. X
  1076. @c [fix-ref Truncating the Stack]
  1077. The Stack buffer is just an Emacs buffer, and you can move around in
  1078. it using the regular Emacs motion commands.  But no matter where the
  1079. cursor is, even if you have scrolled the @samp{.} marker out of
  1080. view, most Calc commands always move the cursor back down to level 1
  1081. before doing anything.  It is possible to move the @samp{.} marker
  1082. upwards through the stack, temporarily ``hiding'' some numbers from
  1083. commands like @kbd{+}.  This is called @dfn{stack truncation} and
  1084. we will not cover it in this tutorial; @pxref{Truncating the Stack},
  1085. if you are interested.
  1086. X
  1087. You don't really need the second @key{RET} in @kbd{2 @key{RET} 3
  1088. @key{RET} +}.  That's because if you type any operator name or
  1089. other non-numeric key when you are entering a number, the Calculator
  1090. automatically enters that number and then does the requested command.
  1091. Thus @kbd{2 @key{RET} 3 +} will work just as well.@refill
  1092. X
  1093. Examples in this tutorial will often omit @key{RET} even when the
  1094. stack displays shown would only happen if you did press @key{RET}:
  1095. X
  1096. @group
  1097. @smallexample
  1098. 1:  2          2:  2          1:  5
  1099. X    .          1:  3              .
  1100. X                   .
  1101. X
  1102. X  2 RET            3              +
  1103. @end smallexample
  1104. @end group
  1105. X
  1106. @noindent
  1107. Here, after pressing @kbd{3} the stack would really show @samp{1:  2}
  1108. with @samp{Calc:@: 3} in the minibuffer.  In these situations, you can
  1109. press the optional @key{RET} to see the stack as the figure shows.
  1110. X
  1111. (@bullet{}) @strong{Exercise 1.}  (This tutorial will include exercises
  1112. at various points.  Try them if you wish.  Answers to all the exercises
  1113. are located at the end of the Tutorial chapter.  Each exercise will
  1114. include a cross-reference to its particular answer.  If you are
  1115. reading with the Emacs Info system, press @kbd{f} and the
  1116. exercise number to go to the answer, then the letter @kbd{l} to
  1117. return to where you were.)
  1118. X
  1119. @noindent
  1120. Here's the first exercise:  What will the keystrokes @kbd{1 @key{RET} 2
  1121. @key{RET} 3 @key{RET} 4 + * -} compute?  (@samp{*} is the symbol for
  1122. multiplication.)  Figure it out by hand, then try it with Calc to see
  1123. if you're right.  @xref{RPN Answer 1, 1}. (@bullet{})
  1124. X
  1125. (@bullet{}) @strong{Exercise 2.}  Compute @c{$2\times4 + 7\times9.4 + {5\over4}$}
  1126. @cite{2*4 + 7*9.5 + 5/4} using the
  1127. stack.  @xref{RPN Answer 2, 2}. (@bullet{})
  1128. X
  1129. The @key{DEL} key is called Backspace on some keyboards.  It is
  1130. whatever key you would use to correct a simple typing error when
  1131. regularly using Emacs.  The @key{DEL} key pops and throws away the
  1132. top value on the stack.  (You can still get that value back from
  1133. the Trail if you should need it later on.)  There are many places
  1134. in this tutorial where we assume you have used @key{DEL} to erase the
  1135. results of the previous example at the beginning of a new example.
  1136. In the few places where it is really important to use @key{DEL} to
  1137. clear away old results, the text will remind you to do so.
  1138. X
  1139. (It won't hurt to let things accumulate on the stack, except that
  1140. whenever you give a display-mode-changing command Calc will have to
  1141. spend a long time reformatting such a large stack.)
  1142. X
  1143. Since the @kbd{-} key is also an operator (it subtracts the top two
  1144. stack elements), how does one enter a negative number?  Calc uses
  1145. the @kbd{_} (underscore) key to act like the minus sign in a number.
  1146. So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key
  1147. will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine.
  1148. X
  1149. You can also press @kbd{n}, which means ``change sign.''  It changes
  1150. the number at the top of the stack (or the number being entered)
  1151. from positive to negative or vice-versa:  @kbd{5 n @key{RET}}.
  1152. X
  1153. @cindex Duplicating a stack entry
  1154. If you press @key{RET} when you're not entering a number, the effect
  1155. is to duplicate the top number on the stack.  Consider this calculation:
  1156. X
  1157. @group
  1158. @smallexample
  1159. 1:  3          2:  3          1:  9          2:  9          1:  81
  1160. X    .          1:  3              .          1:  9              .
  1161. X                   .                             .
  1162. X
  1163. X  3 RET           RET             *             RET             *
  1164. @end smallexample
  1165. @end group
  1166. X
  1167. @noindent
  1168. (Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^},
  1169. to raise 3 to the fourth power.)
  1170. X
  1171. The space-bar key (denoted @key{SPC} here) performs the same function
  1172. as @key{RET}; you could replace all three occurrences of @key{RET} in
  1173. the above example with @key{SPC} and the effect would be the same.
  1174. X
  1175. @cindex Exchanging stack entries
  1176. Another stack manipulation key is @key{TAB}.  This exchanges the top
  1177. two stack entries.  Suppose you have computed @kbd{2 @key{RET} 3 +}
  1178. to get 5, and then you realize what you really wanted to compute
  1179. was @cite{20 / (2+3)}.
  1180. X
  1181. @group
  1182. @smallexample
  1183. 1:  5          2:  5          2:  20         1:  4
  1184. X    .          1:  20         1:  5              .
  1185. X                   .              .
  1186. X
  1187. X 2 RET 3 +         20            TAB             /
  1188. @end smallexample
  1189. @end group
  1190. X
  1191. @noindent
  1192. Planning ahead, the calculation would have gone like this:
  1193. X
  1194. @group
  1195. @smallexample
  1196. 1:  20         2:  20         3:  20         2:  20         1:  4
  1197. X    .          1:  2          2:  2          1:  5              .
  1198. X                   .          1:  3              .
  1199. X                                  .
  1200. X
  1201. X  20 RET         2 RET            3              +              /
  1202. @end smallexample
  1203. @end group
  1204. X
  1205. A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type
  1206. @key{TAB}).  It rotates the top three elements of the stack upward,
  1207. bringing the object in level 3 to the top.
  1208. X
  1209. @group
  1210. @smallexample
  1211. 1:  10         2:  10         3:  10         3:  20         3:  30
  1212. X    .          1:  20         2:  20         2:  30         2:  10
  1213. X                   .          1:  30         1:  10         1:  20
  1214. X                                  .              .              .
  1215. X
  1216. X  10 RET         20 RET         30 RET         M-TAB          M-TAB
  1217. @end smallexample
  1218. @end group
  1219. X
  1220. (@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are
  1221. on the stack.  Figure out how to add one to the number in level 2
  1222. without affecting the rest of the stack.  Also figure out how to add
  1223. one to the number in level 3.  @xref{RPN Answer 3, 3}. (@bullet{})
  1224. X
  1225. Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two
  1226. arguments from the stack and push a result.  Operations like @kbd{n} and
  1227. @kbd{Q} (square root) pop a single number and push the result.  You can
  1228. think of them as simply operating on the top element of the stack.
  1229. X
  1230. @group
  1231. @smallexample
  1232. 1:  3          1:  9          2:  9          1:  25         1:  5
  1233. X    .              .          1:  16             .              .
  1234. X                                  .
  1235. X
  1236. X  3 RET          RET *        4 RET RET *        +              Q
  1237. @end smallexample
  1238. @end group
  1239. X
  1240. @noindent
  1241. (Note that capital @kbd{Q} means to hold down the Shift key while
  1242. typing @kbd{q}.  Remember, plain unshifted @kbd{q} is the Quit command.)
  1243. X
  1244. @cindex Pythagorean Theorem
  1245. Here we've used the Pythagorean Theorem to determine the hypotenuse of a
  1246. right triangle.  Calc actually has a built-in command for that called
  1247. @kbd{f h}, but let's suppose we can't remember the necessary keystrokes.
  1248. We can still enter it by its full name using @kbd{M-x} notation:
  1249. X
  1250. @group
  1251. @smallexample
  1252. 1:  3          2:  3          1:  5
  1253. X    .          1:  4              .
  1254. X                   .
  1255. X
  1256. X  3 RET          4 RET      M-x calc-hypot
  1257. @end smallexample
  1258. @end group
  1259. X
  1260. All Calculator commands begin with the word @samp{calc-}.  Since it
  1261. gets tiring to type this, Calc provides an @kbd{x} key which is just
  1262. like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-}
  1263. prefix for you:
  1264. X
  1265. @group
  1266. @smallexample
  1267. 1:  3          2:  3          1:  5
  1268. X    .          1:  4              .
  1269. X                   .
  1270. X
  1271. X  3 RET          4 RET         x hypot
  1272. @end smallexample
  1273. @end group
  1274. X
  1275. What happens if you take the square root of a negative number?
  1276. X
  1277. @group
  1278. @smallexample
  1279. 1:  4          1:  -4         1:  (0, 2)
  1280. X    .              .              .
  1281. X
  1282. X  4 RET            n              Q
  1283. @end smallexample
  1284. @end group
  1285. X
  1286. @noindent
  1287. The notation @cite{(a, b)} represents a complex number.
  1288. Complex numbers are more traditionally written @c{$a + b i$}
  1289. @cite{a + b i};
  1290. Calc can display in this format, too, but for now we'll stick to the
  1291. @cite{(a, b)} notation.
  1292. X
  1293. If you don't know how complex numbers work, you can safely ignore this
  1294. feature.  Complex numbers only arise from operations that would be
  1295. errors in a calculator that didn't have complex numbers.  (For example,
  1296. taking the square root or logarithm of a negative number produces a
  1297. complex result.)
  1298. X
  1299. Complex numbers are entered in the notation shown.  The @kbd{(} and
  1300. @kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.''
  1301. X
  1302. @group
  1303. @smallexample
  1304. 1:  ( ...      2:  ( ...      1:  (2, ...    1:  (2, ...    1:  (2, 3)
  1305. X    .          1:  2              .              3              .
  1306. X                   .                             .
  1307. X
  1308. X    (              2              ,              3              )
  1309. @end smallexample
  1310. @end group
  1311. X
  1312. You can perform calculations while entering parts of incomplete objects.
  1313. However, an incomplete object cannot actually participate in a calculation:
  1314. X
  1315. @group
  1316. @smallexample
  1317. 1:  ( ...      2:  ( ...      3:  ( ...      1:  ( ...      1:  ( ...
  1318. X    .          1:  2          2:  2              5              5
  1319. X                   .          1:  3              .              .
  1320. X                                  .
  1321. X                                                             (error)
  1322. X    (             2 RET           3              +              +
  1323. @end smallexample
  1324. @end group
  1325. X
  1326. @noindent
  1327. Adding 5 to an incomplete object makes no sense, so the last command
  1328. produces an error message and leaves the stack the same.
  1329. X
  1330. Incomplete objects can't participate in arithmetic, but they can be
  1331. moved around by the regular stack commands.
  1332. X
  1333. @group
  1334. @smallexample
  1335. 2:  2          3:  2          3:  3          1:  ( ...      1:  (2, 3)
  1336. 1:  3          2:  3          2:  ( ...          2              .
  1337. X    .          1:  ( ...      1:  2              3
  1338. X                   .              .              .
  1339. X
  1340. 2 RET 3 RET        (            M-TAB          M-TAB            )
  1341. @end smallexample
  1342. @end group
  1343. X
  1344. @noindent
  1345. Note that the @kbd{,} (comma) key did not have to be used here.
  1346. When you press @kbd{)} all the stack entries between the incomplete
  1347. entry and the top are collected, so there's never really a reason
  1348. to use the comma.  It's up to you.
  1349. X
  1350. (@bullet{}) @strong{Exercise 4.}  To enter the complex number @cite{(2, 3)},
  1351. your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}.  What happened?
  1352. (Joe thought of a clever way to correct his mistake in only two
  1353. keystrokes, but it didn't quite work.  Try it to find out why.)
  1354. @xref{RPN Answer 4, 4}. (@bullet{})
  1355. X
  1356. Vectors are entered the same way as complex numbers, but with square
  1357. brackets in place of parentheses.  We'll meet vectors again later in
  1358. the tutorial.
  1359. X
  1360. Any Emacs command can be given a @dfn{numeric prefix argument} by
  1361. typing a series of @key{META}-digits beforehand.  If @key{META} is
  1362. awkward for you, you can instead type @kbd{C-u} followed by the
  1363. necessary digits.  Numeric prefix arguments can be negative, as in
  1364. @kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}.  Calc commands use numeric
  1365. prefix arguments in a variety of ways.  For example, a numeric prefix
  1366. on the @kbd{+} operator adds any number of stack entries at once:
  1367. X
  1368. @group
  1369. @smallexample
  1370. 1:  10         2:  10         3:  10         3:  10         1:  60
  1371. X    .          1:  20         2:  20         2:  20             .
  1372. X                   .          1:  30         1:  30
  1373. X                                  .              .
  1374. X
  1375. X  10 RET         20 RET         30 RET         C-u 3            +
  1376. @end smallexample
  1377. @end group
  1378. X
  1379. For stack manipulation commands like @key{RET}, a positive numeric
  1380. prefix argument operates on the top @var{n} stack entries at once.  A
  1381. negative argument operates on the entry in level @var{n} only.  An
  1382. argument of zero operates on the entire stack.  In this example, we copy
  1383. the second-to-top element of the stack:
  1384. X
  1385. @group
  1386. @smallexample
  1387. 1:  10         2:  10         3:  10         3:  10         4:  10
  1388. X    .          1:  20         2:  20         2:  20         3:  20
  1389. X                   .          1:  30         1:  30         2:  30
  1390. X                                  .              .          1:  20
  1391. X                                                                .
  1392. X
  1393. X  10 RET         20 RET         30 RET         C-u -2          RET
  1394. @end smallexample
  1395. @end group
  1396. X
  1397. @cindex Clearing the stack
  1398. @cindex Emptying the stack
  1399. Another common idiom is @kbd{M-0 DEL}, which clears the stack.
  1400. (The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the
  1401. entire stack.)
  1402. X
  1403. @node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial
  1404. @subsection Algebraic-Style Calculations
  1405. X
  1406. @noindent
  1407. If you are not used to RPN notation, you may prefer to operate the
  1408. Calculator in ``algebraic mode,'' which is closer to the way
  1409. non-RPN calculators work.  In algebraic mode, you enter formulas
  1410. in traditional @cite{2+3} notation.
  1411. X
  1412. You don't really need any special ``mode'' to enter algebraic formulas.
  1413. You can enter a formula at any time by pressing the apostrophe (@kbd{'})
  1414. key.  Answer the prompt with the desired formula, then press @key{RET}.
  1415. The formula is evaluated and the result is pushed onto the RPN stack.
  1416. If you don't want to think in RPN at all, you can enter your whole
  1417. computation as a formula, read the result from the stack, then press
  1418. @key{DEL} to delete it from the stack.
  1419. X
  1420. Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}.
  1421. The result should be the number 9.
  1422. X
  1423. Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*},
  1424. @samp{/}, and @samp{^}.  You can use parentheses to make the order
  1425. of evaluation clear.  In the absence of parentheses, @samp{^} is
  1426. evaluated first, then @samp{*}, then @samp{/}, then finally
  1427. SHAR_EOF
  1428. true || echo 'restore of calc.texinfo failed'
  1429. fi
  1430. echo 'End of  part 31'
  1431. echo 'File calc.texinfo is continued in part 32'
  1432. echo 32 > _shar_seq_.tmp
  1433. exit 0
  1434. exit 0 # Just in case...
  1435. -- 
  1436. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1437. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1438. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1439. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1440.